Top 190+ Java Interview Questions and Answers [2024]

OVERVIEW

Java is a widely used programming language known for its simplicity, robustness, and versatility in developing desktop, web, and mobile applications. Its consistent demand in the tech industry makes mastering Java crucial for career growth.

Preparing for Java interview questions is essential to demonstrate your technical expertise and problem-solving skills. By reviewing these questions, you can effectively showcase your knowledge, boost your confidence, and make a strong impression on potential employers. This focused preparation ensures you align with industry expectations and stand out in the competitive job market.

Download Java Interview Questions

Note : We have compiled all the Java Interview Questions for your reference in a template format. Check it out now!

Intermediate-Level Java Interview Questions

This section covers Java interview questions for intermediate-level candidates who have a good grasp of the basics and some programming experience. These questions explore more complex topics like collections, exception handling, multithreading, and serialization.

80. What Is the Final Variable?

A variable declared as final in Java cannot have its value modified after it is initially set. This makes it useful for defining constants or values that must remain unchanged throughout the program. Understanding the concept of final variables is essential for Java developers, and it's often covered in many of the Java interview questions.

81. How Can You Synchronize an ArrayList in Java?

There are two main ways to synchronize an ArrayList in Java, a common topic in Java interview questions:

• Using Collections.synchronizedList() method : This creates a synchronized list backed by the original ArrayList. All access to the list must be done through the returned synchronized list.

List<String> list = Collections.synchronizedList(new ArrayList<String>());

• Using CopyOnWriteArrayList: CopyOnWriteArrayList is a thread-safe variant of ArrayList that achieves thread safety by creating a separate copy of the underlying array for each write operation. This allows for concurrent reads without locking, but write operations are more expensive.

List<String> list = new CopyOnWriteArrayList<String>();

82. Contiguous Memory Locations Are Usually Used for Storing Actual Values in an Array but Not in ArrayList. Explain

Arrays store primitive data types in contiguous memory locations, while ArrayLists store object references instead of the actual primitive values. This is because arrays can directly store primitive data, occupying sequential memory addresses.

On the other hand, ArrayLists manage an internal array that holds references to objects rather than the primitive values themselves. As a result, the memory layout of an ArrayLists is not contiguous like an array since the objects are stored at various locations in memory.

This distinction is important to know for any Java developer, and it often appears in most of the Java interview questions.

83. How Does the Size of ArrayList Grow Dynamically? And State How It Is Implemented Internally

The size of an ArrayList grows dynamically to make space for more elements. When you first create an ArrayList, it usually has a default capacity of about 10 to 16 elements. This number can change depending on the version of Java you are using.

When the current array becomes full, and you try to add more elements, the ArrayList needs to increase its size. It creates a new array that is larger than the old one. The new array is often about one and a half times the size of the old array.

After creating the new array, the ArrayList copies all the elements from the old array to the new array. Once this copying is complete, the ArrayList updates its internal reference to point to the new array. This process of making an array bigger is called resizing.

84. What are Default Methods?

Default methods are methods in an interface that can have a body. These methods allow interfaces to provide default implementations of some methods, making them more flexible. This is a crucial concept for Java interview questions related to the evolution of Java interfaces in Java 8 and beyond.

85. Is Exceeding the Memory Limit Possible in a Program Despite Having a Garbage Collector?

Yes, even with a garbage collector, a program can still run out of memory. Garbage collection helps identify and remove objects that are no longer needed. This process frees up resources used by these objects.

When an object becomes unreachable in a program, garbage collection is triggered for that object. If there is not enough memory to create new objects, the garbage collector works to free memory from objects that are no longer in scope. However, if the amount of memory released is not enough to create new objects, the program can exceed its memory limit. Garbage collection is the core aspect of Java, and it’s often mentioned in most of the Java interview questions.

86. What Are the Differences Between Abstract Class and Interface?

In object-oriented programming (OOP), both abstract classes and interfaces are essential constructs for creating contracts that define specific behaviors for implementing classes. Understanding the differences between these two is important, as they are commonly discussed topics in Java interview questions.

Below are the detailed differences between abstract classes and interfaces:

87. What is a Collection Framework in Java?

Collections in Java refer to groups of objects. The collection framework is a set of interfaces and classes that represent and manage these groups of objects in different ways. It includes classes like ArrayList, Vector, LinkedList, PriorityQueue, and TreeSet.

Additionally, the framework provides multiple interfaces, including Set, List, Queue, and Deque. Each interface is designed to store a specific type of data.

88. How to Make Java ArrayList Read-Only?

In Java, you can create a read-only view of an ArrayList by using the Collections.unmodifiableList() method.

This method takes an existing ArrayList as input and returns an unmodifiable view of that list.

Here's an example:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class UnmodifiableArrayList {
    public static void main(String[] args) {
        List<String> languageList = new ArrayList<>();
        languageList.add("Java");
        languageList.add("Python");
        languageList.add("C++");
        languageList.add("C#");

        List<String> readOnlyList = Collections.unmodifiableList(languageList);

        readOnlyList.add("JavaScript");

        languageList.add("JavaScript");
        System.out.println(languageList); // [Java, Python, C++, C#, JavaScript]
    }
}

In this example, we first create a regular ArrayList called languageList and add some programming languages to it. Then, we use the Collections.unmodifiableList() method to create a read-only view of the languageList called readOnlyList.

89. What Is the Stack Class in Java, and What Are the Various Methods It Provides?

The Stack Class in Java is a data structure that follows the Last-In-First-Out (LIFO) principle. It extends the Vector class and provides specific methods for stack operations. In a stack, elements are added and removed from the top, similar to a stack of plates where you can only add or remove plates from the top.

The various methods provided by the Stack class are:

• push() - Adds an element to the top.
• pop() - Removes and returns the top element.
• peek() - Returns the top element without removing it.
• empty() - Returns true if the stack has no elements.
• search() - Returns the 1-based position of an element from the top.

90. What Is the HashSet Class in Java, and How Does It Store Elements?

The HashSet class in Java is part of the collections framework, which is inherited from the AbstractSet class and implemented in the Set interface. It uses a hashtable, which is a HashMap, to store a collection of unique elements.

The hashtable uses a process called hashing to store information. Hashing converts information into a unique value, or "hash code," which helps locate data linked to a key. This transformation from information to hash code happens automatically within the HashSet.

91. What Is a Map Interface in Java?

The Map interface in Java is a structure that contains a set of key-value pairs, where each key is unique and corresponds to a single value. It is part of the java.util package and is commonly used in Java programming to organize and retrieve data in an ordered fashion, and it’s often asked in most of the Java interview questions. A Map is particularly helpful for searching, updating, or deleting elements based on a key.

92. How To Create Immutable Classes in Java?

To create an immutable class in Java, follow these steps:

• Declare the class as final.
• Make data members private.
• Use final for data members.
• Create a parameterized constructor.
• Implement getter methods for copies.

93. Explain TreeMap in Java

The TreeMap in Java is an implementation of the Map interface, NavigableMap, and AbstractMap class. Depending on the constructor used, it sorts the map according to the natural ordering of its keys or by a Comparator provided during the map's creation.

Features of a TreeMap:

• The TreeMap is part of the Java Collections framework.
• A TreeMap does not accept null keys; attempting to insert a null key will cause a NullPointerException. However, it does allow multiple null values.
• A TreeMap is not synchronized. To use a synchronized version, apply the Collections.synchronizedSortedMap method.

94. What Is EnumSet?

The EnumSet is a specialized form of the Set interface for use with enumeration types.

Some features of EnumSet include:

• EnumSet extends the AbstractSet class and implements the Set interface.
• It is part of the Java Collections Framework but is not synchronized.
• It performs more efficiently than HashSet, offering faster operations.
• All elements within an EnumSet must belong to a single enumeration type, which is defined when creating the set.
• EnumSet does not accept null values, and any attempt to insert null will result in a NullPointerException.
• A fail-safe iterator is used in EnumSet, so modifying the collection during iteration will not cause a ConcurrentModificationException.

95. What Is BlockingQueue?

A BlockingQueue is a type of queue that has operations for handling cases when the queue is empty or full. It will wait until there is something in the queue if we try to retrieve an item from an empty queue, and it will wait for space to free up if we try to add an item to a full queue.

Some important points about BlockingQueue:

• A BlockingQueue may have a maximum capacity. Once this limit is reached, no additional elements can be added without causing a blocking state.
• All BlockingQueue implementations are thread-safe. This is achieved using internal locks or other concurrency mechanisms.
• BlockingQueue does not accept null values. Any attempt to add null will cause a NullPointerException.
• Java provides implementations of BlockingQueue in the java.util.concurrent package.

96. What Is the ConcurrentHashMap in Java?

ConcurrentHashMap in Java is a class that implements the ConcurrentMap and Serializable interfaces. This class builds on the HashMap to work efficiently in multithreaded environments. ConcurrentHashMap provides improved performance over HashMap in these cases, as it handles concurrent updates and retrievals without the need for synchronization on the whole map, making it more suitable and effective for multithreaded tasks.

97. What Is an Iterator?

In Java, an Iterator is a type of cursor used to loop through a collection of objects one at a time. It is an interface found in the java.util package that provides access to elements in a collection.

The Iterator is often referred to as Java’s universal cursor since it works with any class in the Collection framework. It supports actions like reading and removing items from the collection. Compared to the older Enumeration interface, Iterator provides methods with simpler and clearer names, making it easier to use.

98. What Is an Enumeration?

An enumeration (enum) in Java is a unique data type that includes a fixed set of predefined constants.

99. What Is the Difference Between Collection and Collections?

A common topic that often appears in Java interview questions is the difference between collection and collections in Java.

Here's a concise comparison:

100. Explain the FailFast Iterator and FailSafe Iterator, Along With Examples for Each.

In Java, an iterator is used to traverse a collection's objects.

Collections provide two types of iterators: Fail Fast and Fail Safe.

Fail Fast Iterator: Fail Fast iterators immediately throw a ConcurrentModificationException if the collection undergoes structural changes during iteration. Structural changes include adding, removing, or updating elements while another thread is iterating over the collection. Examples of Fail Fast iterators include those from ArrayList and HashMap.

import java.util.HashMap;   
import java.util.Iterator;   
import java.util.Map;   

public class FailFastExample {  
    public static void main(String[] args) {   
        Map<String, String> cityMap = new HashMap<String, String>();   
        
        cityMap.put("Harry", "London");   
        cityMap.put("Ron", "Paris");   
        cityMap.put("Hermione", "Tokyo");   
        
        Iterator iterator = cityMap.keySet().iterator();   
        
        while (iterator.hasNext()) {   
            System.out.println(cityMap.get(iterator.next()));   

            cityMap.put("Brown", "Sydney");   
        }   
    }   
}

Fail Safe Iterator: Fail Safe iterators work differently from Fail Fast iterators. They do not throw exceptions when the collection is modified during iteration. This is because they work on a copy of the collection instead of the original. Any structural changes made to the original collection do not affect the copy, so the original collection remains unchanged during iteration.

Although the term "Fail Safe" is not explicitly used in Java SE documentation, it is often referred to as a non-Fail Fast iterator.

import java.util.concurrent.CopyOnWriteArrayList;   
import java.util.Iterator;   

class FailSafeExample {   
    public static void main(String args[]) {   
        CopyOnWriteArrayList<Integer> numbers 
            = new CopyOnWriteArrayList<Integer>(new Integer[] { 5, 10, 15, 20 });   
            
        Iterator itr = numbers.iterator();   
        while (itr.hasNext()) {   
            Integer value = (Integer)itr.next();   
            System.out.println(value);   
            if (value == 10) {
                numbers.add(25);
            }
        }   
    }   
}

101. What Is Exception Handling?.

Exception handling is a method for managing runtime errors that may occur in a program. Examples of such errors include ClassNotFoundException , IOException, SQLException, and RemoteException. This mechanism helps maintain the normal flow of the application by allowing the program to respond appropriately when an error occurs.

102. How Many Types of Exceptions Can Occur in a Java Program?

In Java, there are two main types of exceptions:

Built-in Exceptions: These are exceptions provided by Java libraries to represent specific error situations.

Here are some important built-in exceptions:

• ArrayIndexOutOfBoundsException
• ClassNotFoundException
• FileNotFoundException
• NullPointerException
• RuntimeException
• StringIndexOutOfBoundsException
• IllegalArgumentException
• IllegalStateException

User-Defined Exceptions: In some cases, built-in exceptions may not effectively describe a specific situation. In these instances, users can create their exceptions, known as user-defined exceptions.

103. What Is NullPointerException?

A NullPointerException (NPE) is one of Java's most common runtime exceptions. It occurs when code attempts to operate on a null object reference.

This happens in scenarios like:

• Accessing methods or fields of a null object.
• Accessing array elements when the array is null.
• Dereferencing null objects.

104. When Is the ArrayStoreException Thrown?

An ArrayStoreException in Java happens when there is an attempt to store an object of an incorrect type in an array.

This exception extends the RuntimeException class, which means it occurs during the execution of a program. This is the most commonly occurred expectation in Java and is often asked in many of the Java interview questions.

105. What Is the Base Class for Error and Exception??

The base class for both Error and Exception in Java is the Throwable class.

106. Is It Necessary That Each Try Block Must Be Followed by a Catch Block?

No, it is not necessary to follow every try block with a catch block in Java. You can use a finally block instead, which runs regardless of whether an exception is thrown.

107. What Is Exception Propagation?

When an exception occurs in Java, it starts from the top of the call stack. If the exception is not caught in that method, it moves down to the previous method in the stack. This process continues until the exception is caught or it reaches the bottom of the call stack. This process is known as exception propagation.

108. Explain Object Cloning in Java.

Object cloning in Java is a technique used to create an exact copy of an object. The clone() method from the Object class is responsible for cloning an object.

To enable cloning, a class must implement the java.lang.Cloneable interface. If the class does not implement this interface, invoking the clone() method will result in a CloneNotSupportedException.

The clone() method is defined in the Object class and is used to perform the cloning operation. Below is the syntax of the clone() method:

protected Object clone() throws CloneNotSupportedException

109. What Is the Difference Between This() and Super() in Java?

Below are the differences between this() and super() in Java:

110. What Is Multitasking?

Multitasking means a system can run several tasks at the same time or during overlapping periods. There are two main ways to achieve this: using multiple processes or using multiple threads. In Java, the focus is mainly on multitasking with threads.

111. What Do You Mean by a Multithreaded Program?

Multithreading in Java is a method for executing multiple threads simultaneously. A thread acts as a lightweight sub-process, representing the smallest unit of processing. Both multiprocessing and multithreading achieve multitasking.

However, multithreading is preferred over multiprocessing because threads share a memory area. This means threads do not need separate memory space, which saves memory. Additionally, switching between threads requires less time than switching between processes. Multiprocessing and multithreading are core concepts in Java, and it’s often asked in many of the Java interview questions.

112. What Are the Advantages of Multithreading?

Advantages of Java Multithreading:

• Threads work independently, meaning the user can carry out multiple tasks simultaneously without interruption.
• Performing several operations simultaneously helps to save time.
• Since threads operate independently, an exception in one thread does not affect the others.

113. What Are the Two Ways in Which Thread Can Be Created?

There are two ways to create a thread in Java:

By Extending the Thread Class: You can create a class that extends the java.lang.Thread class. In this class, you need to override the run() method, which contains the code for the thread. The thread starts executing when the run() method is called.

Syntax:

public class MyThread extends Thread {
    public void run() {
        // thread code     }
}

By Implementing the Runnable Interface: In this approach, you create a new class that implements the java.lang.Runnable interface. You must override the run() method in this class. After creating an instance of your Runnable class, you create a Thread object and call the start() method on it to begin execution.

Syntax:

public class MyRunnable implements Runnable {
   public void run() {
      // thread code
   }
}

114. What Is a Thread?

A thread is a lightweight process and represents the smallest unit of a program that can run tasks simultaneously. It helps a program function more efficiently by allowing multiple operations to occur at the same time. Threads are one of the important concepts in Java and it has often been covered in most of the Java interview questions.

In Java, the thread concept is used to perform complex tasks in the background. These tasks execute without interrupting the main program. Each thread in a program has its separate execution path, making every thread independent within the process.

115. Describe the Life Cycle of a Thread

In Java, a thread can exist in one of the following states:

• New: A thread enters the new state when it is created. In this state, the thread's code has not yet run, and it has not started execution.
• Active: When a thread's start() method is called, it moves from the new state to the active state. The active state includes two sub-states: runnable and running.
• Runnable: A thread that is ready to run enters the runnable state. In this state, the thread may either be running or waiting to run. The thread scheduler allocates CPU time to move the thread from runnable to running. Multiple threads in the runnable state may queue up, waiting for their turn to execute.
• Running: When a thread receives CPU time, it transitions from the runnable state to the running state. The most common transition is between runnable and running.
• Blocked or Waiting: A thread becomes inactive for a period when it enters either the blocked or waiting state.
• Timed Waiting: This state occurs when a thread waits for a specified duration to prevent starvation. For example, if one thread is in a critical section and does not exit, another thread may wait for a set amount of time rather than indefinitely.
• Terminated: A thread reaches the termination state when it completes its task or encounters an error, such as an unhandled exception. Once a thread terminates, it cannot be restarted. The terminated thread is considered dead and no longer exists in the system.

116. How To Temporarily Suspend a Thread in Java?

To temporarily suspend a thread in Java, the thread must be in the suspended state, which means it is inactive. The suspend() method is used for this purpose, allowing the thread to remain suspended until it is resumed by the resume() method.

The syntax for the suspend() method is as follows:

public final void suspend()

This method is final, meaning it cannot be overridden by subclasses. It has a void return type that does not return a value. The suspend() method temporarily stops the thread until the resume() method is called.

117. What Is a Daemon Thread?

A daemon thread in Java acts as a service provider thread that supports user threads. Its lifecycle depends on user threads. When all user threads finish execution, the Java Virtual Machine (JVM) automatically terminates the daemon thread.

Several daemon threads run automatically in Java, such as the garbage collector and finalizer threads.

118. What Are the Ways in Which a Thread Can Enter the Waiting State??

A thread can enter the waiting state in several ways. It may be called the sleep() method to pause for a specified duration. It can also become blocked while trying to acquire an object's lock or by calling the wait() method on an object. Additionally, a thread can enter the waiting state by using the suspend() method, although this method is deprecated.

119. What Is Serialization?

Serialization in Java is the process of converting the state of an object into a byte stream. This is one of the core concepts in Java programming language and is often highlighted in most of the Java interview questions.

This byte stream represents the object's data and makes it possible to store or transmit the object. Java I/O (Input/Output) streams are used for this purpose, where a byte stream reads and writes one byte of data at a time, making it suitable for low-level data operations.

120. How Can You Make a Class Serializable in Java?

To make a class serializable in Java, the class must implement the Serializable interface.

121. Can a Serialized Object Be Transferred via Network?

Yes, a serialized object can be transferred over a network in Java.

122. What Is the Difference Between Static and Non-static Methods in Java?

The main difference between static and non-static methods is that static methods can be called without creating an instance of the class, while non-static methods can directly access any static method or static variable without needing to create an instance of the class.

123. What Is Deserialization?

Deserialization refers to converting a byte stream back into an object. It is the reverse operation of serialization, which transforms an object's state into a byte stream for storage or transmission. During deserialization, the byte stream is read and reconstructed into the original object, allowing access to its data and methods.

In Java, the ObjectInputStream class is commonly used for deserialization. It reads the byte stream and recreates the object based on its serialized state. This process is essential for restoring object states after transmission or storage, supporting data exchange and persistence across various platforms.

124. What Is the Reflection?

Reflection refers to the examination or modification of a class's runtime behavior. The java.lang.Class class provides methods to obtain metadata and alter the runtime behavior of a class. The java.lang and java.lang.reflect packages contain classes relevant to Java reflection.

125. What Is the Purpose of Using java.lang.Class Class?

In Java, the java.lang.Class class is a built-in class used to represent a class or interface during runtime. This class includes various methods that provide details about the class or interface. It provides information such as the name of the class, its superclass, implemented interfaces, fields, and methods.

126. What Are the Ways to Instantiate the Class Class?

There are three ways to create an instance of the Class class in Java:

• forName() method of Class class: This method loads a class dynamically and returns an instance of the Class class. It is useful when you know the fully qualified name of the class. However, it cannot be used for primitive types.
• getClass() method of Object class: This method returns an instance of the Class class. It is suitable when you know the type of the object. It can also be used with primitive types.
• .class syntax: If the type is known but there is no instance available, you can obtain a Class instance by appending ".class" to the name of the type. This syntax works for both reference types and primitive data types.

127. What Javap Tool?

The javap tool provides information about a class or interface. Often referred to as the Java Disassembler, it disassembles one or more class files. The output varies based on the options used, such as -c for bytecode or -verbose for detailed bytecode information. If no options are specified, javap displays the package, protected, and public fields and methods of the specified classes.

Syntax:

javap [option] [classname]

128. What Is a Native Method?

The native keyword in Java is used to declare a method that is implemented in native code through the Java Native Interface (JNI). This modifier is exclusive to methods and cannot be applied elsewhere. Methods written in languages like C . or C++ are referred to as native methods or foreign methods.

129. What Are Autoboxing and Unboxing?

Autoboxing refers to converting a primitive value into an object of the corresponding wrapper class. For example, converting an int to an Integer class.

The Java compiler performs autoboxing in the following situations:

• When a primitive value is passed as a parameter to a method that expects an object of the corresponding wrapper class.
• When a primitive value is assigned to a variable of the corresponding wrapper class.

Unboxing refers to converting an object of a wrapper type back into its corresponding primitive value. For example, converting an Integer to an int.

The Java compiler applies unboxing in these scenarios:

• When an object of a wrapper class is passed as a parameter to a method that expects a value of the corresponding primitive type.
• When an object of a wrapper class is assigned to a variable of the corresponding primitive type.

130. What Is the Purpose of the Strictfp Keyword?

In Java, the strictfp modifier stands for strict floating-point. It is used to restrict floating-point calculations, ensuring consistent results across different platforms during operations involving floating-point variables.

131. What Is the Purpose of the System Class?

The System class is part of the java.lang package and cannot be instantiated. Its purpose is to provide standard output and error output streams, handle standard input, and grant access to externally defined properties and environment variables. Additionally, it provides a utility method for efficiently copying portions of an array and a means for loading files and libraries.

132. Which Containers Use a Border Layout As Their Default Layout in Java?

The BorderLayout is the default layout for the Window, Frame, and Dialog class containers in Java.

133. Which Containers in Java Use a FlowLayout As Their Default Layout?

The FlowLayout is the default layout for the Panel and Applet classes in Java.

134. What Is a Lightweight Component?

Lightweight components do not make native calls to acquire graphical units. Instead, they use the graphical units of their parent component for rendering.

135. What Is a Heavyweight Component?

Heavyweight components are the portable elements provided by the operating system. AWT relies on the graphical classes offered by the operating system, implementing only a minimal subset of screen elements supported across all platforms.

The user interface discovery tools dependent on the operating system are classified as heavyweight components.

136. What Is an Applet?

An applet is a Java program that can be embedded directly into a web page. It runs within a web browser, operating on the client side to add interactive elements to websites.

Applets are embedded into HTML pages using the APPLET or OBJECT tags and are hosted on a web server. They provide a means of making web content more engaging and dynamic.

Some key points about applets:

• All applets inherit from the java.applet.Applet class, either directly or indirectly.
• Applets are not independent applications; they run within a web browser or an applet viewer. Java Development Kit (JDK) includes a standard applet viewer tool specifically for this purpose.
• Unlike typical Java applications, applets do not start with the main() method.
• Applet output on its window does not use System.out.println(). Instead, it uses various AWT methods like drawString() to display text and graphics.

137. Explain the Life Cycle of an Applet.

In Java, an applet’s life cycle describes the sequence of steps an applet undergoes during its creation, execution, and termination.

The life cycle consists of five primary methods that the browser invokes during different phases of the applet’s life:

• init(): This is the first method called when an applet is loaded. The init() method initializes the applet, setting up any required objects or variables. It only runs once, marking the initial stage of the applet.
• start(): Following init(), the start() method is invoked. It contains the main logic of the applet and is executed each time the applet becomes active, such as when the browser reloads the page, the applet is maximized, or the user navigates back to the page where the applet is embedded. The applet continues in an active state until it is paused.
• stop(): This method pauses the applet, interrupting its active functions. stop() is called when the applet is minimized, when the user navigates away from the page, or when the applet becomes inactive in the browser. If the user returns to the page, start() is invoked again to resume the applet’s activity.
• destroy(): When the applet is no longer needed, the destroy() method is called. This final method terminates the applet and removes it from memory. After destroy() has been executed, the applet cannot be restarted without reloading the page.
• paint(): The paint() method is used to draw graphical content within the applet, such as shapes or text. It is called immediately after start() and also executes when the applet window is resized. This method is part of the awt.Component class, while the other lifecycle methods belong to the applet.Applet class.

When an applet is first loaded, the sequence begins with init(), followed by start(), and then paint(). When the applet is stopped, stop() and destroy() are called in order to conclude its life cycle. This is one of the most important topics in Java programming language and is often asked in most of the Java interview questions.

138. What Is the Difference Between an Applet and a Java Application?

Java applications and Java applets are both Java programs, but they differ in some aspects. A Java application always begins execution with the main() method. On the other hand, an applet initializes through the init() method without invoking the main() method.

This functions as stand-alone programs that run directly on the underlying operating system with the help of the Java Virtual Machine (JVM). They perform a variety of operations for users and do not rely on APIs or web browsers. Conversely, applets are small programs embedded in web pages. They use the OBJECT or APPLET tag for embedding in HTML pages and are hosted on web servers.

139. Explain Java Socket Programming.

Java socket programming provides a way for communication between two machines using TCP. A client application creates a socket to connect to a server. When a connection occurs, the server produces a socket object to handle the interaction.

The java.net.Socket class represents the client socket, while the java.net.ServerSocket class listens for client connections.

Here are the steps for establishing a TCP connection:

• The server creates a ServerSocket object with a specified port number for communication.
• The server invokes the accept() method of the ServerSocket class, waiting for a client connection.
• The client creates a socket object and provides the server's name and port number.
• The constructor of the Socket class attempts to connect the client to the specified server and port number. If successful, the client obtains a Socket object to communicate with the server.
• The accept() method on the server returns a reference to a new socket linked to the client's socket.

Once connected, data can be exchanged through I/O streams. Each socket has an OutputStream and an InputStream. The client's OutputStream connects to the server's InputStream, while the server's OutputStream connects to the client's InputStream.

140. What Is Socket?

A socket is an endpoint for communication between machines. It provides the connection mechanism to link two computers using TCP. The Socket class can be utilized to create a socket.

141. What Is RMI?

RMI stands for Remote Method Invocation. It is an API that allows one object to invoke a method on another object residing in a different address space. This can occur on the same machine or a remote machine. RMI provides a way for an object running in one Java Virtual Machine (JVM) to call methods on an object in another JVM.

142. What Is a Servlet?

A servlet is a class in the Java programming language that increases the functions of servers that support applications based on the request-response programming model. Although servlets are capable of responding to any type of request, they are often used to extend the features of applications hosted on web servers. Java Servlet technology provides HTTP-specific servlet classes to support these types of applications.

143. What Is the Difference Between an Applet and a Servlet?

In Java, Applets and Servlets are both types of programs that run within a Java environment. Applets are created to provide interactive features that can be embedded into web pages, enabling users to interact with content directly within their web browsers.

On the other hand, Servlets function on the server side, where they manage requests and responses, playing a crucial role in generating dynamic content for web applications.

144. What Is a JavaBean?

Reusability is a fundamental focus in any programming language. To address this need, Java introduced the concept of JavaBeans. A JavaBean is a software component that can be reused across different environments.

Simply put, JavaBeans are classes that consolidate multiple objects into a single entity, making it possible to access these objects from various locations within an application. JavaBeans contain several key elements, including constructors, getter and setter methods, and additional components that support reusability and flexibility in development.

145. What Do You Understand by the Bean Persistent Property?

The persistence property of a JavaBean refers to its ability to save and restore the values of its properties, fields, and state information.

146. What Is the Purpose of Stub and Skeleton?

• Stub: The stub is an object that functions as a gateway on the client side. All outgoing requests from the client pass through it. It resides on the client side and represents the remote object.

When a caller invokes a method on the stub object, the stub performs the following tasks:

• Initiates a connection with the remote Virtual Machine (JVM).
• Writes and sends (marshals) the parameters to the remote JVM.
• It waits for the response.
• Reads (unmarshals) the return value or exception.
• Returns the value to the caller.
• Skeleton: The skeleton is an object that acts as a gateway on the server side. It handles all incoming requests for the server-side object.

When the skeleton receives a request, it performs the following tasks:

• Read the parameters for the remote method.
• Invokes the method on the actual remote object.
• Writes and sends (marshals) the result back to the caller.

147. What Are the Steps Involved In Writing RMI-Based Programs?

Writing RMI-based programs involves six steps:

• Create the remote interface.
• Implement the remote interface.
• Generate the stub and skeleton objects using the rmic tool.
• Start the registry service using the rmiregistry tool.
• Develop and run the server application.
• Develop and run the client application.

148. What Is the Purpose of the Volatile Keyword in Java?

The purpose of the volatile keyword in Java is to make sure that changes to a variable are visible to all threads. When a variable is declared as volatile, any thread that reads the variable will see the most recent value written to it. This helps prevent data inconsistencies when multiple threads are accessing and modifying the same variable. This keyword is important for Java developers to know, and it’s often highlighted in most Java interview questions.

The intermediate-level Java interview questions listed above are designed to help both beginners and those with some experience prepare effectively for interviews. As you progress in your Java development career, you will encounter more challenging questions that are particularly relevant for experienced developers. These questions will help you deepen your understanding and expertise in various Java concepts and technologies, ensuring you're well-prepared for more advanced roles.

Experienced-Level Java Interview Questions

This section is for experienced Java developers and includes Java interview questions on advanced topics. These questions cover some advanced topics and practical coding questions that test your problem-solving skills.

149. Explain Garbage Collection in Java

Garbage collection in Java is the process of reclaiming memory by removing objects that are no longer needed in a program. Unlike languages such as C and C++, where the programmer manually manages memory by creating and deleting objects, Java handles this automatically through garbage collection.

In Java, memory management occurs as objects are created on the heap during the program's runtime. Some of these objects become unused over time, either because they’re no longer referenced or they’ve outlived their purpose. The Java garbage collector identifies these dead objects that are no longer needed and removes them from memory, freeing up space for new objects.

This automated approach to memory management helps prevent memory leaks, which can occur when unneeded objects remain in memory. Eventually, this leads to program crashes with "OutOfMemoryErrors." By handling memory cleanup automatically, Java reduces the risk of memory-related errors, supporting a smoother runtime experience.

150. What Is the Role of the Finalize() Method in Java Garbage Collection?

The finalize() method in Java helps clean up before an object is removed from memory. When the garbage collector is about to delete an object, it calls finalize() to release any resources the object is holding, which helps keep memory use efficient.

151. What Is a Memory Leak?

In Java, a memory leak occurs when the garbage collector fails to identify and reclaim unused objects. These objects remain in memory indefinitely, which reduces the available memory for the application. As a result, the application may encounter an OutOfMemoryError because the unused objects are still referenced.

152. How Can You Prevent Memory Leaks in Java?

To prevent memory leaks in Java, consider these important points:

Do not create objects that are not needed, as they consume memory.

• Use StringBuilder instead of String concatenation, as String concatenation creates multiple temporary String objects that lead to wasted memory.
• Avoid storing large amounts of data in the session to reduce memory usage.
• Set session timeouts to free memory when sessions are no longer needed.
• Avoid calling System.gc() as it does not guarantee immediate garbage collection and can affect performance.
• Static objects remain in memory for the application's lifetime. If no longer needed, explicitly set their references to null to allow garbage collection.
• Always close ResultSet, Statement, and Connection objects in the final block to release database resources properly.

153. What Is Spring?

Spring is an open-source framework for enterprise Java development. It offers core features applicable to any Java application and provides extensions for creating web applications within the Java EE platform. The Spring framework aims to simplify J2EE development and encourages good programming practices through a POJO-based (Plain Old Java Object) programming model.

154. What Does System.gc() and Runtime.gc() Methods Do?

Both System.gc() and Runtime.gc() methods in Java are used to request garbage collection. Garbage collection is the process where the Java Virtual Machine (JVM) reclaims memory from objects that are no longer reachable or needed, freeing up resources.

Key Points:

• System.gc():
• A static method from the System class.
• It serves as a suggestion to the JVM to perform garbage collection.
• Internally calls the Runtime.getRuntime().gc() method.
• Runtime.gc():
• A non-static method of the Runtime class.
• Explicitly requests the JVM to start garbage collection through the current runtime instance.

Common Behavior:

• Both methods provide only a hint to the JVM; they do not guarantee immediate garbage collection.
• The actual execution depends on the JVM's implementation and garbage collector strategy.

Example:

public class GarbageCollectionExample {
    public static void main(String[] args) {
        // Suggesting garbage collection using System.gc()
        System.gc();


        // Suggesting garbage collection using Runtime.gc()
        Runtime.getRuntime().gc();
    }
}

155. What Are Spring Beans?

In Spring, the objects that are the backbone of your application and managed by the Spring IoC container are known as beans. A bean is an object that the Spring IoC container instantiates, assembles, and manages. These beans are created based on the configuration metadata you provide to the container.

156. Does Spring Bean Provide Thread Safety?

Spring beans do not guarantee thread safety by default because their default scope is singleton. This means there is only one instance of the bean per context. Multiple threads accessing class-level variables that can be modified can lead to inconsistent data.

To achieve thread safety, changing the scope of a Spring bean to request, prototype, or session can be useful. Each of these scopes creates a new instance of the bean for each request or session. This reduces the risk of data inconsistency. However, this approach may impact performance.

157. What Is Double Brace Initialization in Java?

Double Brace Initialization in Java refers to the combination of two processes. As the name suggests, this technique uses two sets of braces {{.

A single brace { is familiar to most programmers. The first brace in double brace initialization creates an anonymous inner class. This approach is common in Java programming. The second brace distinguishes this technique from standard brace usage in Java.

This second brace is an initialization block for the declared anonymous inner class. When used together, this initialization block and the anonymous inner class constitute what is known as Java double brace initialization.

158. What Is the Drawback of Garbage Collection?

Here are some drawbacks of garbage collection:

• Garbage collection requires extra processing time and system resources. This can lead to slower program performance and increased memory use.
• It can be difficult to predict when memory will be cleaned up. This unpredictable behavior makes it harder to write reliable code.
• Some garbage collection methods need to pause the program to free up memory. These pauses can be noticeable in real-time applications and cause issues.
• Garbage collection can lead to memory fragmentation. This means that free memory blocks may become scattered throughout the heap. As a result, the program may struggle to allocate large blocks of memory efficiently.

159. Name Some Classes Present in java.util.regex Package.

The java.util.regex package contains classes including Pattern, Matcher, and PatternSyntaxException.

160. What Is JDBC?

JDBC stands for Java Database Connectivity. It is a Java API that is used to connect and execute queries with a database. JDBC requires specific JDBC drivers to connect to various database systems. This API can access tabular data stored in any relational database.

161. What Is a JDBC Driver?

A JDBC driver is a software component that allows a Java application to communicate with a database.

There are four main types of JDBC drivers:

• JDBC-ODBC Bridge Driver
• Native-API Driver
• Network Protocol Driver
• Thin Driver

162. What Are Java Testing Frameworks?

Java testing frameworks consist of a set of rules designed to support the creation and execution of test scripts. These frameworks provide guidelines for coding standards, handling test data, managing object repositories, and offering libraries.

Here are some widely used Java testing frameworks:

• Selenium: This is an open-source tool for testing web applications. It works with different browsers and operating systems. Selenium automates repetitive tasks, making it easier to deploy software.
• JUnit: JUnit is a popular framework for testing Java code. It encourages writing tests before the actual code, which helps catch errors early. JUnit makes it simple to write tests and check for problems.
• Cucumber: Cucumber is used for behavior-driven development. It allows testers to write tests in plain language that everyone can understand. These tests describe how a system should behave using simple statements.
• Spring: Spring has a testing framework that helps test Spring applications without starting a web server. It makes it easier to test different parts of an application.

While Java testing frameworks like Selenium, JUnit, Cucumber, and Spring provide robust tools for creating and executing test scripts, managing diverse test environments and ensuring cross-browser and cross-platform compatibility can be challenging. This is where cloud-based platforms come into play.

Cloud-based testing platforms, like LambdaTest, integrate seamlessly with popular Java testing frameworks. They offer access to a wide range of browsers, devices, and operating systems, enabling teams to perform parallel testing at scale. LambdaTest is an AI-powered platform for test orchestration and execution that allows you to run manual and automated Java tests at scale across 3000+ browsers and OS combinations.

These platforms eliminate the need for maintaining physical infrastructure, reducing costs and setup time while ensuring comprehensive test coverage.

Additionally, cloud platforms provide advanced features like real-time debugging, CI/CD integration, and secure collaboration among teams, making them an ideal choice for modern testing needs. By leveraging cloud-based solutions you can use various frameworks simultaneously such as Selenium Java, Selenium Python and more, organizations can accelerate their testing cycles, improve efficiency, and deliver high-quality software faster.

163. What Is the Role of the JDBC DriverManager Class?

The DriverManager class functions as an interface between the user and database drivers. It manages the available drivers and establishes connections between a database and the selected driver. This class maintains a list of driver classes that have registered themselves by calling the method DriverManager.registerDriver().

164. How Is a Checked Exception Different from an Unchecked Exception?

Unchecked exceptions are runtime exceptions that do not need to be caught or declared in a throws clause. They usually occur due to programming errors, such as accessing an invalid index in an array or dividing by zero.

On the other hand, unchecked exceptions include all subclasses of the RuntimeException class, as well as the Error class and its subclasses.

165. Write a Java Program To Check if a Number Is Prime

This program checks if a given number is prime. A prime number is only divisible by 1 and itself, meaning it has no other divisors. In this example, we iterate through an array of numbers 1, 23, 4, and 31, checking each one to see if it meets the criteria of a prime number and printing the result accordingly.

public class PrimeNumbers {
    public static void main(String[] args) {
        int[] numbersToCheck = {1, 23, 4, 31};

        for (int number : numbersToCheck) {
            boolean isPrime = isPrime(number);
            if (isPrime) {
                System.out.println(number + " is a prime number.");
            } else {
                System.out.println(number + " is not a prime number.");
            }
        }
    }

    public static boolean isPrime(int num) {
        if (num <= 1) {
            return false;
        }
        if (num == 2) {
            return true;         }
        if (num % 2 == 0) {
            return false;         }
        for (int i = 3; i <= Math.sqrt(num); i += 2) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
}

166. Write a Java Program To Swap Two Numbers Without Using a Third Variable

This program swaps two numbers without using a third variable. Instead of an additional variable, it uses the XOR bitwise operator to exchange values directly. In this example, we start with the numbers 14 and 24, then apply three XOR operations to swap their values.

public class SwapNumbers{
    public static void main(String[] args) {
        int a = 14;
        int b = 24;

        System.out.println("Before swapping: a = " + a + ", b = " + b);

        // Swapping using XOR
        a = a ^ b; 
        b = a ^ b; 
        a = a ^ b; 

        System.out.println("After swapping: a = " + a + ", b = " + b);
    }
}